home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / sh-utils.12 / sh-utils / sh-utils-1.12 / src / stty.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  43.0 KB  |  1,711 lines
  1. /* stty -- change and print terminal line settings
  2.    Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17.  
  18. /* Usage: stty [-ag] [--all] [--save] [setting...]
  19.  
  20.    Options:
  21.    -a, --all    Write all current settings to stdout in human-readable form.
  22.    -g, --save   Write all current settings to stdout in stty-readable form.
  23.  
  24.    If no args are given, write to stdout the baud rate and settings that
  25.    have been changed from their defaults.  Mode reading and changes
  26.    are done on stdin.
  27.  
  28.    David MacKenzie <djm@gnu.ai.mit.edu> */
  29.  
  30. #include <config.h>
  31. #include <stdio.h>
  32. #include <sys/types.h>
  33. #include <termios.h>
  34. #ifdef GWINSZ_IN_SYS_IOCTL
  35. #include <sys/ioctl.h>
  36. #endif
  37. #ifdef WINSIZE_IN_PTEM
  38. #include <sys/stream.h>
  39. #include <sys/ptem.h>
  40. #endif
  41. #include <getopt.h>
  42. #ifdef __STDC__
  43. #include <stdarg.h>
  44. #define VA_START(args, lastarg) va_start(args, lastarg)
  45. #else
  46. #include <varargs.h>
  47. #define VA_START(args, lastarg) va_start(args)
  48. #endif
  49.  
  50. #include "system.h"
  51. #include "version.h"
  52. #include "long-options.h"
  53.  
  54. #if defined(GWINSZ_BROKEN)    /* Such as for SCO UNIX 3.2.2. */
  55. #undef TIOCGWINSZ
  56. #endif
  57.  
  58. #ifndef _POSIX_VDISABLE
  59. #define _POSIX_VDISABLE ((unsigned char) 0)
  60. #endif
  61.  
  62. #define Control(c) ((c) & 0x1f)
  63. /* Canonical values for control characters. */
  64. #ifndef CINTR
  65. #define CINTR Control ('c')
  66. #endif
  67. #ifndef CQUIT
  68. #define CQUIT 28
  69. #endif
  70. #ifndef CERASE
  71. #define CERASE 127
  72. #endif
  73. #ifndef CKILL
  74. #define CKILL Control ('u')
  75. #endif
  76. #ifndef CEOF
  77. #define CEOF Control ('d')
  78. #endif
  79. #ifndef CEOL
  80. #define CEOL _POSIX_VDISABLE
  81. #endif
  82. #ifndef CSTART
  83. #define CSTART Control ('q')
  84. #endif
  85. #ifndef CSTOP
  86. #define CSTOP Control ('s')
  87. #endif
  88. #ifndef CSUSP
  89. #define CSUSP Control ('z')
  90. #endif
  91. #if defined(VEOL2) && !defined(CEOL2)
  92. #define CEOL2 _POSIX_VDISABLE
  93. #endif
  94. #if defined(VSWTCH) && !defined(CSWTCH)
  95. #define CSWTCH _POSIX_VDISABLE
  96. #endif
  97.  
  98. /* SunOS 5.3 loses (^Z doesn't work) if `swtch' is the same as `susp'.
  99.    So the default is to disable `swtch.'  */
  100. #if defined (__sparc__) && defined (__svr4__)
  101. #undef CSWTCH
  102. #define CSWTCH _POSIX_VDISABLE
  103. #endif
  104.  
  105. #if defined(VWERSE) && !defined (VWERASE)    /* AIX-3.2.5 */
  106. #define VWERASE VWERSE
  107. #endif
  108. #if defined(VDSUSP) && !defined (CDSUSP)
  109. #define CDSUSP Control ('y')
  110. #endif
  111. #if !defined(VREPRINT) && defined(VRPRNT)    /* Irix 4.0.5 */
  112. #define VREPRINT VRPRNT
  113. #endif
  114. #if defined(VREPRINT) && !defined(CRPRNT)
  115. #define CRPRNT Control ('r')
  116. #endif
  117. #if defined(VWERASE) && !defined(CWERASE)
  118. #define CWERASE Control ('w')
  119. #endif
  120. #if defined(VLNEXT) && !defined(CLNEXT)
  121. #define CLNEXT Control ('v')
  122. #endif
  123. #if defined(VDISCARD) && !defined(VFLUSHO)
  124. #define VFLUSHO VDISCARD
  125. #endif
  126. #if defined(VFLUSH) && !defined(VFLUSHO)    /* Ultrix 4.2 */
  127. #define VFLUSHO VFLUSH
  128. #endif
  129. #if defined(VFLUSHO) && !defined(CFLUSHO)
  130. #define CFLUSHO Control ('o')
  131. #endif
  132. #if defined(VSTATUS) && !defined(CSTATUS)
  133. #define CSTATUS Control ('t')
  134. #endif
  135.  
  136. static const char *visible ();
  137. static unsigned long baud_to_value ();
  138. static int recover_mode ();
  139. static int screen_columns ();
  140. static int set_mode ();
  141. static long integer_arg ();
  142. static speed_t string_to_baud ();
  143. static tcflag_t *mode_type_flag ();
  144. static void display_all ();
  145. static void display_changed ();
  146. static void display_recoverable ();
  147. static void display_settings ();
  148. static void display_speed ();
  149. static void display_window_size ();
  150. static void sane_mode ();
  151. static void set_control_char ();
  152. static void set_speed ();
  153. static void set_window_size ();
  154.  
  155. void error ();
  156.  
  157. /* Which speeds to set.  */
  158. enum speed_setting
  159.   {
  160.     input_speed, output_speed, both_speeds
  161.   };
  162.  
  163. /* What to output and how.  */
  164. enum output_type
  165.   {
  166.     changed, all, recoverable    /* Default, -a, -g.  */
  167.   };
  168.  
  169. /* Which member(s) of `struct termios' a mode uses.  */
  170. enum mode_type
  171.   {
  172.     control, input, output, local, combination
  173.   };
  174.  
  175. /* Flags for `struct mode_info'. */
  176. #define SANE_SET 1        /* Set in `sane' mode. */
  177. #define SANE_UNSET 2        /* Unset in `sane' mode. */
  178. #define REV 4            /* Can be turned off by prepending `-'. */
  179. #define OMIT 8            /* Don't display value. */
  180.  
  181. /* Each mode.  */
  182. struct mode_info
  183.   {
  184.     const char *name;        /* Name given on command line.  */
  185.     enum mode_type type;    /* Which structure element to change. */
  186.     char flags;            /* Setting and display options.  */
  187.     unsigned long bits;        /* Bits to set for this mode.  */
  188.     unsigned long mask;        /* Other bits to turn off for this mode.  */
  189.   };
  190.  
  191. static struct mode_info mode_info[] =
  192. {
  193.   {"parenb", control, REV, PARENB, 0},
  194.   {"parodd", control, REV, PARODD, 0},
  195.   {"cs5", control, 0, CS5, CSIZE},
  196.   {"cs6", control, 0, CS6, CSIZE},
  197.   {"cs7", control, 0, CS7, CSIZE},
  198.   {"cs8", control, 0, CS8, CSIZE},
  199.   {"hupcl", control, REV, HUPCL, 0},
  200.   {"hup", control, REV | OMIT, HUPCL, 0},
  201.   {"cstopb", control, REV, CSTOPB, 0},
  202.   {"cread", control, SANE_SET | REV, CREAD, 0},
  203.   {"clocal", control, REV, CLOCAL, 0},
  204. #ifdef CRTSCTS
  205.   {"crtscts", control, REV, CRTSCTS, 0},
  206. #endif
  207.  
  208.   {"ignbrk", input, SANE_UNSET | REV, IGNBRK, 0},
  209.   {"brkint", input, SANE_SET | REV, BRKINT, 0},
  210.   {"ignpar", input, REV, IGNPAR, 0},
  211.   {"parmrk", input, REV, PARMRK, 0},
  212.   {"inpck", input, REV, INPCK, 0},
  213.   {"istrip", input, REV, ISTRIP, 0},
  214.   {"inlcr", input, SANE_UNSET | REV, INLCR, 0},
  215.   {"igncr", input, SANE_UNSET | REV, IGNCR, 0},
  216.   {"icrnl", input, SANE_SET | REV, ICRNL, 0},
  217.   {"ixon", input, REV, IXON, 0},
  218.   {"ixoff", input, SANE_UNSET | REV, IXOFF, 0},
  219.   {"tandem", input, REV | OMIT, IXOFF, 0},
  220. #ifdef IUCLC
  221.   {"iuclc", input, SANE_UNSET | REV, IUCLC, 0},
  222. #endif
  223. #ifdef IXANY
  224.   {"ixany", input, SANE_UNSET | REV, IXANY, 0},
  225. #endif
  226. #ifdef IMAXBEL
  227.   {"imaxbel", input, SANE_SET | REV, IMAXBEL, 0},
  228. #endif
  229.  
  230.   {"opost", output, SANE_SET | REV, OPOST, 0},
  231. #ifdef OLCUC
  232.   {"olcuc", output, SANE_UNSET | REV, OLCUC, 0},
  233. #endif
  234. #ifdef OCRNL
  235.   {"ocrnl", output, SANE_UNSET | REV, OCRNL, 0},
  236. #endif
  237. #ifdef ONLCR
  238.   {"onlcr", output, SANE_SET | REV, ONLCR, 0},
  239. #endif
  240. #ifdef ONOCR
  241.   {"onocr", output, SANE_UNSET | REV, ONOCR, 0},
  242. #endif
  243. #ifdef ONLRET
  244.   {"onlret", output, SANE_UNSET | REV, ONLRET, 0},
  245. #endif
  246. #ifdef OFILL
  247.   {"ofill", output, SANE_UNSET | REV, OFILL, 0},
  248. #endif
  249. #ifdef OFDEL
  250.   {"ofdel", output, SANE_UNSET | REV, OFDEL, 0},
  251. #endif
  252. #ifdef NLDLY
  253.   {"nl1", output, SANE_UNSET, NL1, NLDLY},
  254.   {"nl0", output, SANE_SET, NL0, NLDLY},
  255. #endif
  256. #ifdef CRDLY
  257.   {"cr3", output, SANE_UNSET, CR3, CRDLY},
  258.   {"cr2", output, SANE_UNSET, CR2, CRDLY},
  259.   {"cr1", output, SANE_UNSET, CR1, CRDLY},
  260.   {"cr0", output, SANE_SET, CR0, CRDLY},
  261. #endif
  262. #ifdef TABDLY
  263.   {"tab3", output, SANE_UNSET, TAB3, TABDLY},
  264.   {"tab2", output, SANE_UNSET, TAB2, TABDLY},
  265.   {"tab1", output, SANE_UNSET, TAB1, TABDLY},
  266.   {"tab0", output, SANE_SET, TAB0, TABDLY},
  267. #else
  268. #ifdef OXTABS
  269.   {"tab3", output, SANE_UNSET, OXTABS, 0},
  270. #endif
  271. #endif
  272. #ifdef BSDLY
  273.   {"bs1", output, SANE_UNSET, BS1, BSDLY},
  274.   {"bs0", output, SANE_SET, BS0, BSDLY},
  275. #endif
  276. #ifdef VTDLY
  277.   {"vt1", output, SANE_UNSET, VT1, VTDLY},
  278.   {"vt0", output, SANE_SET, VT0, VTDLY},
  279. #endif
  280. #ifdef FFDLY
  281.   {"ff1", output, SANE_UNSET, FF1, FFDLY},
  282.   {"ff0", output, SANE_SET, FF0, FFDLY},
  283. #endif
  284.  
  285.   {"isig", local, SANE_SET | REV, ISIG, 0},
  286.   {"icanon", local, SANE_SET | REV, ICANON, 0},
  287. #ifdef IEXTEN
  288.   {"iexten", local, SANE_SET | REV, IEXTEN, 0},
  289. #endif
  290.   {"echo", local, SANE_SET | REV, ECHO, 0},
  291.   {"echoe", local, SANE_SET | REV, ECHOE, 0},
  292.   {"crterase", local, REV | OMIT, ECHOE, 0},
  293.   {"echok", local, SANE_SET | REV, ECHOK, 0},
  294.   {"echonl", local, SANE_UNSET | REV, ECHONL, 0},
  295.   {"noflsh", local, SANE_UNSET | REV, NOFLSH, 0},
  296. #ifdef XCASE
  297.   {"xcase", local, SANE_UNSET | REV, XCASE, 0},
  298. #endif
  299. #ifdef TOSTOP
  300.   {"tostop", local, SANE_UNSET | REV, TOSTOP, 0},
  301. #endif
  302. #ifdef ECHOPRT
  303.   {"echoprt", local, SANE_UNSET | REV, ECHOPRT, 0},
  304.   {"prterase", local, REV | OMIT, ECHOPRT, 0},
  305. #endif
  306. #ifdef ECHOCTL
  307.   {"echoctl", local, SANE_SET | REV, ECHOCTL, 0},
  308.   {"ctlecho", local, REV | OMIT, ECHOCTL, 0},
  309. #endif
  310. #ifdef ECHOKE
  311.   {"echoke", local, SANE_SET | REV, ECHOKE, 0},
  312.   {"crtkill", local, REV | OMIT, ECHOKE, 0},
  313. #endif
  314.  
  315.   {"evenp", combination, REV | OMIT, 0, 0},
  316.   {"parity", combination, REV | OMIT, 0, 0},
  317.   {"oddp", combination, REV | OMIT, 0, 0},
  318.   {"nl", combination, REV | OMIT, 0, 0},
  319.   {"ek", combination, OMIT, 0, 0},
  320.   {"sane", combination, OMIT, 0, 0},
  321.   {"cooked", combination, REV | OMIT, 0, 0},
  322.   {"raw", combination, REV | OMIT, 0, 0},
  323.   {"pass8", combination, REV | OMIT, 0, 0},
  324.   {"litout", combination, REV | OMIT, 0, 0},
  325.   {"cbreak", combination, REV | OMIT, 0, 0},
  326. #ifdef IXANY
  327.   {"decctlq", combination, REV | OMIT, 0, 0},
  328. #endif
  329. #if defined (TABDLY) || defined (OXTABS)
  330.   {"tabs", combination, REV | OMIT, 0, 0},
  331. #endif
  332. #if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
  333.   {"lcase", combination, REV | OMIT, 0, 0},
  334.   {"LCASE", combination, REV | OMIT, 0, 0},
  335. #endif
  336.   {"crt", combination, OMIT, 0, 0},
  337.   {"dec", combination, OMIT, 0, 0},
  338.  
  339.   {NULL, control, 0, 0, 0}
  340. };
  341.  
  342. /* Control character settings.  */
  343. struct control_info
  344.   {
  345.     const char *name;        /* Name given on command line.  */
  346.     unsigned char saneval;    /* Value to set for `stty sane'.  */
  347.     int offset;            /* Offset in c_cc.  */
  348.   };
  349.  
  350. /* Control characters. */
  351.  
  352. static struct control_info control_info[] =
  353. {
  354.   {"intr", CINTR, VINTR},
  355.   {"quit", CQUIT, VQUIT},
  356.   {"erase", CERASE, VERASE},
  357.   {"kill", CKILL, VKILL},
  358.   {"eof", CEOF, VEOF},
  359.   {"eol", CEOL, VEOL},
  360. #ifdef VEOL2
  361.   {"eol2", CEOL2, VEOL2},
  362. #endif
  363. #ifdef VSWTCH
  364.   {"swtch", CSWTCH, VSWTCH},
  365. #endif
  366.   {"start", CSTART, VSTART},
  367.   {"stop", CSTOP, VSTOP},
  368.   {"susp", CSUSP, VSUSP},
  369. #ifdef VDSUSP
  370.   {"dsusp", CDSUSP, VDSUSP},
  371. #endif
  372. #ifdef VREPRINT
  373.   {"rprnt", CRPRNT, VREPRINT},
  374. #endif
  375. #ifdef VWERASE
  376.   {"werase", CWERASE, VWERASE},
  377. #endif
  378. #ifdef VLNEXT
  379.   {"lnext", CLNEXT, VLNEXT},
  380. #endif
  381. #ifdef VFLUSHO
  382.   {"flush", CFLUSHO, VFLUSHO},
  383. #endif
  384. #ifdef VSTATUS
  385.   {"status", CSTATUS, VSTATUS},
  386. #endif
  387.  
  388.   /* These must be last because of the display routines. */
  389.   {"min", 1, VMIN},
  390.   {"time", 0, VTIME},
  391.   {NULL, 0, 0}
  392. };
  393.  
  394. /* The width of the screen, for output wrapping. */
  395. static int max_col;
  396.  
  397. /* Current position, to know when to wrap. */
  398. static int current_col;
  399.  
  400. static struct option longopts[] =
  401. {
  402.   {"all", no_argument, NULL, 'a'},
  403.   {"save", no_argument, NULL, 'g'},
  404.   {NULL, 0, NULL, 0}
  405. };
  406.  
  407. /* The name this program was run with. */
  408. char *program_name;
  409.  
  410. /* Print format string MESSAGE and optional args.
  411.    Wrap to next line first if it won't fit.
  412.    Print a space first unless MESSAGE will start a new line. */
  413.  
  414. /* VARARGS */
  415. static void
  416. #ifdef __STDC__
  417. wrapf (const char *message,...)
  418. #else
  419. wrapf (message, va_alist)
  420.      const char *message;
  421.      va_dcl
  422. #endif
  423. {
  424.   va_list args;
  425.   char buf[1024];        /* Plenty long for our needs. */
  426.   int buflen;
  427.  
  428.   VA_START (args, message);
  429.   vsprintf (buf, message, args);
  430.   va_end (args);
  431.   buflen = strlen (buf);
  432.   if (current_col + (current_col > 0) + buflen >= max_col)
  433.     {
  434.       putchar ('\n');
  435.       current_col = 0;
  436.     }
  437.   if (current_col > 0)
  438.     {
  439.       putchar (' ');
  440.       current_col++;
  441.     }
  442.   fputs (buf, stdout);
  443.   current_col += buflen;
  444. }
  445.  
  446. static void
  447. usage (status)
  448.      int status;
  449. {
  450.   if (status != 0)
  451.     fprintf (stderr, "Try `%s --help' for more information.\n",
  452.          program_name);
  453.   else
  454.     {
  455.       printf ("\
  456. Usage: %s [SETTING]...\n\
  457.   or:  %s OPTION\n\
  458. ",
  459.           program_name, program_name);
  460.       printf ("\
  461. \n\
  462.   -a, --all       print all current settings in human-readable form\n\
  463.   -g, --save      print all current settings in a stty-readable form\n\
  464.       --help      display this help and exit\n\
  465.       --version   output version information and exit\n\
  466. \n\
  467. Optional - before SETTING indicates negation.  An * marks non-POSIX\n\
  468. settings.  The underlying system defines which settings are available.\n\
  469. ");
  470.       printf ("\
  471. \n\
  472. Special characters:\n\
  473. * dsusp CHAR    CHAR will send a terminal stop signal once input flushed\n\
  474.   eof CHAR      CHAR will send an end of file (terminate the input)\n\
  475.   eol CHAR      CHAR will end the line\n\
  476. * eol2 CHAR     alternate CHAR for ending the line\n\
  477.   erase CHAR    CHAR will erase the last character typed\n\
  478.   intr CHAR     CHAR will send an interrupt signal\n\
  479.   kill CHAR     CHAR will erase the current line\n\
  480. * lnext CHAR    CHAR will enter the next character quoted\n\
  481.   quit CHAR     CHAR will send a quit signal\n\
  482. * rprnt CHAR    CHAR will redraw the current line\n\
  483.   start CHAR    CHAR will restart the output after stopping it\n\
  484.   stop CHAR     CHAR will stop the output\n\
  485.   susp CHAR     CHAR will send a terminal stop signal\n\
  486. * swtch CHAR    CHAR will switch to a different shell layer\n\
  487. * werase CHAR   CHAR will erase the last word typed\n\
  488. ");
  489.       printf ("\
  490. \n\
  491. Special settings:\n\
  492.   N             set the input and output speeds to N bauds\n\
  493. * cols N        tell the kernel that the terminal has N columns\n\
  494. * columns N     same as cols N\n\
  495.   ispeed N      set the input speed to N\n\
  496. * line N        use line discipline N\n\
  497.   min N         with -icanon, set N characters minimum for a completed read\n\
  498.   ospeed N      set the output speed to N\n\
  499. * rows N        tell the kernel that the terminal has N rows\n\
  500. * size          print the number of rows and columns according to the kernel\n\
  501.   speed         print the terminal speed\n\
  502.   time N        with -icanon, set read timeout of N tenths of a second\n\
  503. ");
  504.       printf ("\
  505. \n\
  506. Control settings:\n\
  507.   [-]clocal     disable modem control signals\n\
  508.   [-]cread      allow input to be received\n\
  509. * [-]crtscts    enable RTS/CTS handshaking\n\
  510.   csN           set character size to N bits, N in [5..8]\n\
  511.   [-]cstopb     use two stop bits per character (one with `-')\n\
  512.   [-]hup        send a hangup signal when the last process closes the tty\n\
  513.   [-]hupcl      same as [-]hup\n\
  514.   [-]parenb     generate parity bit in output and expect parity bit in input\n\
  515.   [-]parodd     set odd parity (even with `-')\n\
  516. ");
  517.       printf ("\
  518. \n\
  519. Input settings:\n\
  520.   [-]brkint     breaks cause an interrupt signal\n\
  521.   [-]icrnl      translate carriage return to newline\n\
  522.   [-]ignbrk     ignore breaks\n\
  523.   [-]igncr      ignore carriage return\n\
  524.   [-]ignpar     ignore parity errors\n\
  525. * [-]imaxbel    beep and do not flush a full input buffer on a character\n\
  526.   [-]inlcr      translate newline to carriage return\n\
  527.   [-]inpck      enable input parity checking\n\
  528.   [-]istrip     clear high (8th) bit of input characters\n\
  529. * [-]iuclc      translate uppercase characters to lowercase\n\
  530. * [-]ixany      let any character restart output, not only start character\n\
  531.   [-]ixoff      enable sending of start/stop characters\n\
  532.   [-]ixon       enable XON/XOFF flow control\n\
  533.   [-]parmrk     mark parity errors (with a 255-0-character sequence)\n\
  534.   [-]tandem     same as [-]ixoff\n\
  535. ");
  536.       printf ("\
  537. \n\
  538. Output settings:\n\
  539. * bsN           backspace delay style, N in [0..1]\n\
  540. * crN           carriage return delay style, N in [0..3]\n\
  541. * ffN           form feed delay style, N in [0..1]\n\
  542. * nlN           newline delay style, N in [0..1]\n\
  543. * [-]ocrnl      translate carriage return to newline\n\
  544. * [-]ofdel      use delete characters for fill instead of null characters\n\
  545. * [-]ofill      use fill (padding) characters instead of timing for delays\n\
  546. * [-]olcuc      translate lowercase characters to uppercase\n\
  547. * [-]onlcr      translate newline to carriage return-newline\n\
  548. * [-]onlret     newline performs a carriage return\n\
  549. * [-]onocr      do not print carriage returns in the first column\n\
  550.   [-]opost      postprocess output\n\
  551. * tabN          horizontal tab delay style, N in [0..3]\n\
  552. * tabs          same as tab0\n\
  553. * -tabs         same as tab3\n\
  554. * vtN           vertical tab delay style, N in [0..1]\n\
  555. ");
  556.       printf ("\
  557. \n\
  558. Local settings:\n\
  559.   [-]crterase   echo erase characters as backspace-space-backspace\n\
  560. * crtkill       kill all line by obeying the echoprt and echoe settings\n\
  561. * -crtkill      kill all line by obeying the echoctl and echok settings\n\
  562. * [-]ctlecho    echo control characters in hat notation (`^c')\n\
  563.   [-]echo       echo input characters\n\
  564. * [-]echoctl    same as [-]ctlecho\n\
  565.   [-]echoe      same as [-]crterase\n\
  566.   [-]echok      echo a newline after a kill character\n\
  567. * [-]echoke     same as [-]crtkill\n\
  568.   [-]echonl     echo newline even if not echoing other characters\n\
  569. * [-]echoprt    echo erased characters backward, between `\\' and '/'\n\
  570.   [-]icanon     enable erase, kill, werase, and rprnt special characters\n\
  571.   [-]iexten     enable non-POSIX special characters\n\
  572.   [-]isig       enable interrupt, quit, and suspend special characters\n\
  573.   [-]noflsh     disable flushing after interrupt and quit special characters\n\
  574. * [-]prterase   same as [-]echoprt\n\
  575. * [-]tostop     stop background jobs that try to write to the terminal\n\
  576. * [-]xcase      with icanon, escape with `\\' for uppercase characters\n\
  577. ");
  578.       printf ("\
  579. \n\
  580. Combination settings:\n\
  581. * [-]LCASE      same as [-]lcase\n\
  582.   cbreak        same as -icanon\n\
  583.   -cbreak       same as icanon\n\
  584.   cooked        same as brkint ignpar istrip icrnl ixon opost isig\n\
  585.                 icanon, eof and eol characters to their default values\n\
  586.   -cooked       same as raw\n\
  587.   crt           same as echoe echoctl echoke\n\
  588.   dec           same as echoe echoctl echoke -ixany intr ^c erase 0177\n\
  589.                 kill ^u\n\
  590. * [-]decctlq    same as [-]ixany\n\
  591.   ek            erase and kill characters to their default values\n\
  592.   evenp         same as parenb -parodd cs7\n\
  593.   -evenp        same as -parenb cs8\n\
  594. * [-]lcase      same as xcase iuclc olcuc\n\
  595.   litout        same as -parenb -istrip -opost cs8\n\
  596.   -litout       same as parenb istrip opost cs7\n\
  597.   nl            same as -icrnl -onlcr\n\
  598.   -nl           same as icrnl -inlcr -igncr onlcr -ocrnl -onlret\n\
  599.   oddp          same as parenb parodd cs7\n\
  600.   -oddp         same as -parenb cs8\n\
  601.   [-]parity     same as [-]evenp\n\
  602.   pass8         same as -parenb -istrip cs8\n\
  603.   -pass8        same as parenb istrip cs7\n\
  604.   raw           same as -ignbrk -brkint -ignpar -parmrk -inpck -istrip\n\
  605.                 -inlcr -igncr -icrnl  -ixon  -ixoff  -iuclc  -ixany\n\
  606.                 -imaxbel -opost -isig -icanon -xcase min 1 time 0\n\
  607.   -raw          same as cooked\n\
  608.   sane          same as cread -ignbrk brkint -inlcr -igncr icrnl\n\
  609.                 -ixoff -iucl -ixany imaxbel opost -olcuc -ocrnl onlcr\n\
  610.                 -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0\n\
  611.                 isig icanon iexten echo echoe echok -echonl -noflsh\n\
  612.                 -xcase -tostop -echoprt echoctl echoke, all special\n\
  613.                 characters to their default values.\n\
  614. ");
  615.       printf ("\
  616. \n\
  617. Handle the tty line connected to standard input.  Without arguments,\n\
  618. prints baud rate, line discipline, and deviations from stty sane.  In\n\
  619. settings, CHAR is taken literally, or coded as in ^c, 0x37, 0177 or\n\
  620. 127; special values ^- or undef used to disable special characters.\n\
  621. ");
  622.     }
  623.   exit (status);
  624. }
  625.  
  626. void
  627. main (argc, argv)
  628.      int argc;
  629.      char **argv;
  630. {
  631.   struct termios mode;
  632.   enum output_type output_type;
  633.   int optc;
  634.   int require_set_attr;
  635.   int speed_was_set;
  636.   int verbose_output;
  637.   int recoverable_output;
  638.   int k;
  639.  
  640.   program_name = argv[0];
  641.  
  642.   parse_long_options (argc, argv, "stty", version_string, usage);
  643.  
  644.   output_type = changed;
  645.   verbose_output = 0;
  646.   recoverable_output = 0;
  647.  
  648.   /* Recognize the long options only.  */
  649.   opterr = 0;
  650.   while ((optc = getopt_long_only (argc, argv, "ag", longopts, (int *) 0))
  651.      != EOF)
  652.     {
  653.       switch (optc)
  654.     {
  655.     case 'a':
  656.       verbose_output = 1;
  657.       output_type = all;
  658.       break;
  659.  
  660.     case 'g':
  661.       recoverable_output = 1;
  662.       output_type = recoverable;
  663.       break;
  664.  
  665.     default:
  666.       break;
  667.     }
  668.     }
  669.  
  670.   /* Recognize short options and combinations: -a, -g, -ag, and -ga.
  671.      They need not precede non-options.  We cannot use GNU getopt because
  672.      it would treat -tabs and -ixany as uses of the -a option.  */
  673.   for (k = optind; k < argc; k++)
  674.     {
  675.       if (argv[k][0] == '-')
  676.     {
  677.       if (argv[k][1] == 'a'
  678.           && argv[k][2] == '\0')
  679.         {
  680.           ++optind;
  681.           verbose_output = 1;
  682.         }
  683.       else if (argv[k][1] == 'g'
  684.            && argv[k][2] == '\0')
  685.         {
  686.           ++optind;
  687.           recoverable_output = 1;
  688.         }
  689.       else if ((argv[k][1] == 'g'
  690.             && argv[k][2] == 'a'
  691.             && argv[k][3] == '\0')
  692.            || (argv[k][1] == 'a'
  693.                && argv[k][2] == 'g'
  694.                && argv[k][3] == '\0'))
  695.         {
  696.           ++optind;
  697.           verbose_output = 1;
  698.           recoverable_output = 1;
  699.         }
  700.     }
  701.     }
  702.  
  703.   /* Specifying both -a and -g gets an error.  */
  704.   if (verbose_output && recoverable_output)
  705.     error (2, 0,
  706.        "the options for verbose and stty-readable output styles are\n\
  707. \tmutually exclusive");
  708.  
  709.   /* Specifying any other arguments with -a or -g gets an error.  */
  710.   if (argc - optind > 0 && (verbose_output || recoverable_output))
  711.     error (2, 0, "when specifying an output style, modes may not be set");
  712.  
  713.   /* Initialize to all zeroes so there is no risk memcmp will report a
  714.      spurious difference in an uninitialized portion of the structure.  */
  715.   bzero (&mode, sizeof (mode));
  716.   if (tcgetattr (0, &mode))
  717.     error (1, errno, "standard input");
  718.  
  719.   if (verbose_output || recoverable_output || argc == 1)
  720.     {
  721.       max_col = screen_columns ();
  722.       current_col = 0;
  723.       display_settings (output_type, &mode);
  724.       exit (0);
  725.     }
  726.  
  727.   speed_was_set = 0;
  728.   require_set_attr = 0;
  729.   k = 1;
  730.   while (k < argc)
  731.     {
  732.       int match_found = 0;
  733.       int reversed = 0;
  734.       int i;
  735.  
  736.       if (argv[k][0] == '-')
  737.     {
  738.       ++argv[k];
  739.       reversed = 1;
  740.     }
  741.       for (i = 0; mode_info[i].name != NULL; ++i)
  742.     {
  743.       if (!strcmp (argv[k], mode_info[i].name))
  744.         {
  745.           match_found = set_mode (&mode_info[i], reversed, &mode);
  746.           require_set_attr = 1;
  747.           break;
  748.         }
  749.     }
  750.       if (match_found == 0 && reversed)
  751.     {
  752.       error (0, 0, "invalid argument `%s'", --argv[k]);
  753.       usage (1);
  754.     }
  755.       if (match_found == 0)
  756.     {
  757.       for (i = 0; control_info[i].name != NULL; ++i)
  758.         {
  759.           if (!strcmp (argv[k], control_info[i].name))
  760.         {
  761.           if (k == argc - 1)
  762.             {
  763.               error (0, 0, "missing argument to `%s'", argv[k]);
  764.               usage (1);
  765.             }
  766.           match_found = 1;
  767.           ++k;
  768.           set_control_char (&control_info[i], argv[k], &mode);
  769.           require_set_attr = 1;
  770.           break;
  771.         }
  772.         }
  773.     }
  774.       if (match_found == 0)
  775.     {
  776.       if (!strcmp (argv[k], "ispeed"))
  777.         {
  778.           if (k == argc - 1)
  779.         {
  780.           error (0, 0, "missing argument to `%s'", argv[k]);
  781.           usage (1);
  782.         }
  783.           ++k;
  784.           set_speed (input_speed, argv[k], &mode);
  785.           speed_was_set = 1;
  786.           require_set_attr = 1;
  787.         }
  788.       else if (!strcmp (argv[k], "ospeed"))
  789.         {
  790.           if (k == argc - 1)
  791.         {
  792.           error (0, 0, "missing argument to `%s'", argv[k]);
  793.           usage (1);
  794.         }
  795.           ++k;
  796.           set_speed (output_speed, argv[k], &mode);
  797.           speed_was_set = 1;
  798.           require_set_attr = 1;
  799.         }
  800. #ifdef TIOCGWINSZ
  801.       else if (!strcmp (argv[k], "rows"))
  802.         {
  803.           if (k == argc - 1)
  804.         {
  805.           error (0, 0, "missing argument to `%s'", argv[k]);
  806.           usage (1);
  807.         }
  808.           ++k;
  809.           set_window_size ((int) integer_arg (argv[k]), -1);
  810.         }
  811.       else if (!strcmp (argv[k], "cols")
  812.            || !strcmp (argv[k], "columns"))
  813.         {
  814.           if (k == argc - 1)
  815.         {
  816.           error (0, 0, "missing argument to `%s'", argv[k]);
  817.           usage (1);
  818.         }
  819.           ++k;
  820.           set_window_size (-1, (int) integer_arg (argv[k]));
  821.         }
  822.       else if (!strcmp (argv[k], "size"))
  823.         {
  824.           max_col = screen_columns ();
  825.           current_col = 0;
  826.           display_window_size (0);
  827.         }
  828. #endif
  829. #ifdef HAVE_C_LINE
  830.       else if (!strcmp (argv[k], "line"))
  831.         {
  832.           if (k == argc - 1)
  833.         {
  834.           error (0, 0, "missing argument to `%s'", argv[k]);
  835.           usage (1);
  836.         }
  837.           ++k;
  838.           mode.c_line = integer_arg (argv[k]);
  839.           require_set_attr = 1;
  840.         }
  841. #endif
  842.       else if (!strcmp (argv[k], "speed"))
  843.         {
  844.           max_col = screen_columns ();
  845.           display_speed (&mode, 0);
  846.         }
  847.       else if (string_to_baud (argv[k]) != (speed_t) -1)
  848.         {
  849.           set_speed (both_speeds, argv[k], &mode);
  850.           speed_was_set = 1;
  851.           require_set_attr = 1;
  852.         }
  853.       else
  854.         {
  855.           if (recover_mode (argv[k], &mode) == 0)
  856.         {
  857.           error (0, 0, "invalid argument `%s'", argv[k]);
  858.           usage (1);
  859.         }
  860.           require_set_attr = 1;
  861.         }
  862.     }
  863.       k++;
  864.     }
  865.  
  866.   if (require_set_attr)
  867.     {
  868.       struct termios new_mode;
  869.  
  870.       if (tcsetattr (0, TCSADRAIN, &mode))
  871.     error (1, errno, "standard input");
  872.  
  873.       /* POSIX (according to Zlotnick's book) tcsetattr returns zero if
  874.      it performs *any* of the requested operations.  This means it
  875.      can report `success' when it has actually failed to perform
  876.      some proper subset of the requested operations.  To detect
  877.      this partial failure, get the current terminal attributes and
  878.      compare them to the requested ones.  */
  879.  
  880.       /* Initialize to all zeroes so there is no risk memcmp will report a
  881.      spurious difference in an uninitialized portion of the structure.  */
  882.       bzero (&new_mode, sizeof (new_mode));
  883.       if (tcgetattr (0, &new_mode))
  884.     error (1, errno, "standard input");
  885.  
  886.       /* Normally, one shouldn't use memcmp to compare structures that
  887.      may have `holes' containing uninitialized data, but we have been
  888.      careful to initialize the storage of these two variables to all
  889.      zeroes.  One might think it more efficient simply to compare the
  890.      modified fields, but that would require enumerating those fields --
  891.      and not all systems have the same fields in this structure.  */
  892.  
  893.       if (memcmp (&mode, &new_mode, sizeof (mode)) != 0)
  894.     {
  895. #ifdef CIBAUD
  896.       /* SunOS 4.1.3 (at least) has the problem that after this sequence,
  897.          tcgetattr(&m1); tcsetattr(&m1); tcgetattr(&m2);
  898.          sometimes (m1 != m2).  The only difference is in the four bits
  899.          of the c_cflag field corresponding to the baud rate.  To save
  900.          Sun users a little confusion, don't report an error if this
  901.          happens.  But suppress the error only if we haven't tried to
  902.          set the baud rate explicitly -- otherwise we'd never give an
  903.          error for a true failure to set the baud rate.  */
  904.  
  905.       new_mode.c_cflag &= (~CIBAUD);
  906.       if (speed_was_set || memcmp (&mode, &new_mode, sizeof (mode)) != 0)
  907. #endif
  908.         error (1, 0,
  909.           "standard input: unable to perform all requested operations");
  910.     }
  911.     }
  912.  
  913.   exit (0);
  914. }
  915.  
  916. /* Return 0 if not applied because not reversible; otherwise return 1. */
  917.  
  918. static int
  919. set_mode (info, reversed, mode)
  920.      struct mode_info *info;
  921.      int reversed;
  922.      struct termios *mode;
  923. {
  924.   tcflag_t *bitsp;
  925.  
  926.   if (reversed && (info->flags & REV) == 0)
  927.     return 0;
  928.  
  929.   bitsp = mode_type_flag (info->type, mode);
  930.  
  931.   if (bitsp == NULL)
  932.     {
  933.       /* Combination mode. */
  934.       if (!strcmp (info->name, "evenp") || !strcmp (info->name, "parity"))
  935.     {
  936.       if (reversed)
  937.         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
  938.       else
  939.         mode->c_cflag = (mode->c_cflag & ~PARODD & ~CSIZE) | PARENB | CS7;
  940.     }
  941.       else if (!strcmp (info->name, "oddp"))
  942.     {
  943.       if (reversed)
  944.         mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
  945.       else
  946.         mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARODD | PARENB;
  947.     }
  948.       else if (!strcmp (info->name, "nl"))
  949.     {
  950.       if (reversed)
  951.         {
  952.           mode->c_iflag = (mode->c_iflag | ICRNL) & ~INLCR & ~IGNCR;
  953.           mode->c_oflag = (mode->c_oflag
  954. #ifdef ONLCR
  955.                    | ONLCR
  956. #endif
  957.         )
  958. #ifdef OCRNL
  959.         & ~OCRNL
  960. #endif
  961. #ifdef ONLRET
  962.         & ~ONLRET
  963. #endif
  964.         ;
  965.         }
  966.       else
  967.         {
  968.           mode->c_iflag = mode->c_iflag & ~ICRNL;
  969. #ifdef ONLCR
  970.           mode->c_oflag = mode->c_oflag & ~ONLCR;
  971. #endif
  972.         }
  973.     }
  974.       else if (!strcmp (info->name, "ek"))
  975.     {
  976.       mode->c_cc[VERASE] = CERASE;
  977.       mode->c_cc[VKILL] = CKILL;
  978.     }
  979.       else if (!strcmp (info->name, "sane"))
  980.     sane_mode (mode);
  981.       else if (!strcmp (info->name, "cbreak"))
  982.     {
  983.       if (reversed)
  984.         mode->c_lflag |= ICANON;
  985.       else
  986.         mode->c_lflag &= ~ICANON;
  987.     }
  988.       else if (!strcmp (info->name, "pass8"))
  989.     {
  990.       if (reversed)
  991.         {
  992.           mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
  993.           mode->c_iflag |= ISTRIP;
  994.         }
  995.       else
  996.         {
  997.           mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
  998.           mode->c_iflag &= ~ISTRIP;
  999.         }
  1000.     }
  1001.       else if (!strcmp (info->name, "litout"))
  1002.     {
  1003.       if (reversed)
  1004.         {
  1005.           mode->c_cflag = (mode->c_cflag & ~CSIZE) | CS7 | PARENB;
  1006.           mode->c_iflag |= ISTRIP;
  1007.           mode->c_oflag |= OPOST;
  1008.         }
  1009.       else
  1010.         {
  1011.           mode->c_cflag = (mode->c_cflag & ~PARENB & ~CSIZE) | CS8;
  1012.           mode->c_iflag &= ~ISTRIP;
  1013.           mode->c_oflag &= ~OPOST;
  1014.         }
  1015.     }
  1016.       else if (!strcmp (info->name, "raw") || !strcmp (info->name, "cooked"))
  1017.     {
  1018.       if ((info->name[0] == 'r' && reversed)
  1019.           || (info->name[0] == 'c' && !reversed))
  1020.         {
  1021.           /* Cooked mode. */
  1022.           mode->c_iflag |= BRKINT | IGNPAR | ISTRIP | ICRNL | IXON;
  1023.           mode->c_oflag |= OPOST;
  1024.           mode->c_lflag |= ISIG | ICANON;
  1025. #if VMIN == VEOF
  1026.           mode->c_cc[VEOF] = CEOF;
  1027. #endif
  1028. #if VTIME == VEOL
  1029.           mode->c_cc[VEOL] = CEOL;
  1030. #endif
  1031.         }
  1032.       else
  1033.         {
  1034.           /* Raw mode. */
  1035.           mode->c_iflag = 0;
  1036.           mode->c_oflag &= ~OPOST;
  1037.           mode->c_lflag &= ~(ISIG | ICANON
  1038. #ifdef XCASE
  1039.                  | XCASE
  1040. #endif
  1041.         );
  1042.           mode->c_cc[VMIN] = 1;
  1043.           mode->c_cc[VTIME] = 0;
  1044.         }
  1045.     }
  1046. #ifdef IXANY
  1047.       else if (!strcmp (info->name, "decctlq"))
  1048.     {
  1049.       if (reversed)
  1050.         mode->c_iflag |= IXANY;
  1051.       else
  1052.         mode->c_iflag &= ~IXANY;
  1053.     }
  1054. #endif
  1055. #ifdef TABDLY
  1056.       else if (!strcmp (info->name, "tabs"))
  1057.     {
  1058.       if (reversed)
  1059.         mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB3;
  1060.       else
  1061.         mode->c_oflag = (mode->c_oflag & ~TABDLY) | TAB0;
  1062.     }
  1063. #else
  1064. #ifdef OXTABS
  1065.       else if (!strcmp (info->name, "tabs"))
  1066.     {
  1067.       if (reversed)
  1068.         mode->c_oflag = mode->c_oflag | OXTABS;
  1069.       else
  1070.         mode->c_oflag = mode->c_oflag & ~OXTABS;
  1071.     }
  1072. #endif
  1073. #endif
  1074. #if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
  1075.       else if (!strcmp (info->name, "lcase")
  1076.            || !strcmp (info->name, "LCASE"))
  1077.     {
  1078.       if (reversed)
  1079.         {
  1080.           mode->c_lflag &= ~XCASE;
  1081.           mode->c_iflag &= ~IUCLC;
  1082.           mode->c_oflag &= ~OLCUC;
  1083.         }
  1084.       else
  1085.         {
  1086.           mode->c_lflag |= XCASE;
  1087.           mode->c_iflag |= IUCLC;
  1088.           mode->c_oflag |= OLCUC;
  1089.         }
  1090.     }
  1091. #endif
  1092.       else if (!strcmp (info->name, "crt"))
  1093.     mode->c_lflag |= ECHOE
  1094. #ifdef ECHOCTL
  1095.       | ECHOCTL
  1096. #endif
  1097. #ifdef ECHOKE
  1098.       | ECHOKE
  1099. #endif
  1100.       ;
  1101.       else if (!strcmp (info->name, "dec"))
  1102.     {
  1103.       mode->c_cc[VINTR] = 3;    /* ^C */
  1104.       mode->c_cc[VERASE] = 127;    /* DEL */
  1105.       mode->c_cc[VKILL] = 21;    /* ^U */
  1106.       mode->c_lflag |= ECHOE
  1107. #ifdef ECHOCTL
  1108.         | ECHOCTL
  1109. #endif
  1110. #ifdef ECHOKE
  1111.         | ECHOKE
  1112. #endif
  1113.         ;
  1114. #ifdef IXANY
  1115.       mode->c_iflag &= ~IXANY;
  1116. #endif
  1117.     }
  1118.     }
  1119.   else if (reversed)
  1120.     *bitsp = *bitsp & ~info->mask & ~info->bits;
  1121.   else
  1122.     *bitsp = (*bitsp & ~info->mask) | info->bits;
  1123.  
  1124.   return 1;
  1125. }
  1126.  
  1127. static void
  1128. set_control_char (info, arg, mode)
  1129.      struct control_info *info;
  1130.      char *arg;
  1131.      struct termios *mode;
  1132. {
  1133.   unsigned char value;
  1134.  
  1135.   if (!strcmp (info->name, "min") || !strcmp (info->name, "time"))
  1136.     value = integer_arg (arg);
  1137.   else if (arg[0] == '\0' || arg[1] == '\0')
  1138.     value = arg[0];
  1139.   else if (!strcmp (arg, "^-") || !strcmp (arg, "undef"))
  1140.     value = _POSIX_VDISABLE;
  1141.   else if (arg[0] == '^' && arg[1] != '\0')    /* Ignore any trailing junk. */
  1142.     {
  1143.       if (arg[1] == '?')
  1144.     value = 127;
  1145.       else
  1146.     value = arg[1] & ~0140;    /* Non-letters get weird results. */
  1147.     }
  1148.   else
  1149.     value = integer_arg (arg);
  1150.   mode->c_cc[info->offset] = value;
  1151. }
  1152.  
  1153. static void
  1154. set_speed (type, arg, mode)
  1155.      enum speed_setting type;
  1156.      char *arg;
  1157.      struct termios *mode;
  1158. {
  1159.   speed_t baud;
  1160.  
  1161.   baud = string_to_baud (arg);
  1162.   if (type == input_speed || type == both_speeds)
  1163.     cfsetispeed (mode, baud);
  1164.   if (type == output_speed || type == both_speeds)
  1165.     cfsetospeed (mode, baud);
  1166. }
  1167.  
  1168. #ifdef TIOCGWINSZ
  1169.  
  1170. /* Get window size information.  First try getting the information
  1171.    associated with standard output and if that fails, try standard input.
  1172.    Return zero for success, non-zero if both ioctl's failed.  */
  1173.  
  1174. static int
  1175. get_win_size (win)
  1176.      struct winsize *win;
  1177. {
  1178.   int err;
  1179.  
  1180.   err = ioctl (1, TIOCGWINSZ, (char *) win);
  1181.   if (err != 0)
  1182.     err = ioctl (0, TIOCGWINSZ, (char *) win);
  1183.   return err;
  1184. }
  1185.  
  1186. static void
  1187. set_window_size (rows, cols)
  1188.      int rows, cols;
  1189. {
  1190.   struct winsize win;
  1191.  
  1192.   if (get_win_size (&win))
  1193.     {
  1194.       if (errno != EINVAL)
  1195.     error (1, errno, "standard input");
  1196.       bzero (&win, sizeof (win));
  1197.     }
  1198.  
  1199.   if (rows >= 0)
  1200.     win.ws_row = rows;
  1201.   if (cols >= 0)
  1202.     win.ws_col = cols;
  1203.  
  1204. #ifdef TIOCSSIZE
  1205.   /* Alexander Dupuy <dupuy@cs.columbia.edu> wrote:
  1206.      The following code deals with a bug in the SunOS 4.x (and 3.x?) kernel.
  1207.      This comment from sys/ttold.h describes Sun's twisted logic - a better
  1208.      test would have been (ts_lines > 64k || ts_cols > 64k || ts_cols == 0).
  1209.      At any rate, the problem is gone in Solaris 2.x.
  1210.  
  1211.      Unfortunately, the old TIOCSSIZE code does collide with TIOCSWINSZ,
  1212.      but they can be disambiguated by checking whether a "struct ttysize"
  1213.      structure's "ts_lines" field is greater than 64K or not.  If so,
  1214.      it's almost certainly a "struct winsize" instead.
  1215.  
  1216.      At any rate, the bug manifests itself when ws_row == 0; the symptom is
  1217.      that ws_row is set to ws_col, and ws_col is set to (ws_xpixel<<16) +
  1218.      ws_ypixel.  Since GNU stty sets rows and columns separately, this bug
  1219.      caused "stty rows 0 cols 0" to set rows to cols and cols to 0, while
  1220.      "stty cols 0 rows 0" would do the right thing.  On a little-endian
  1221.      machine like the sun386i, the problem is the same, but for ws_col == 0.
  1222.  
  1223.      The workaround is to do the ioctl once with row and col = 1 to set the
  1224.      pixel info, and then do it again using a TIOCSSIZE to set rows/cols.  */
  1225.  
  1226.   if (win.ws_row == 0 || win.ws_col == 0)
  1227.     {
  1228.       struct ttysize ttysz;
  1229.  
  1230.       ttysz.ts_lines = win.ws_row;
  1231.       ttysz.ts_cols = win.ws_col;
  1232.  
  1233.       win.ws_row = 1;
  1234.       win.ws_col = 1;
  1235.  
  1236.       if (ioctl (0, TIOCSWINSZ, (char *) &win))
  1237.     error (1, errno, "standard input");
  1238.  
  1239.       if (ioctl (0, TIOCSSIZE, (char *) &ttysz))
  1240.     error (1, errno, "standard input");
  1241.       return;
  1242.     }
  1243. #endif
  1244.  
  1245.   if (ioctl (0, TIOCSWINSZ, (char *) &win))
  1246.     error (1, errno, "standard input");
  1247. }
  1248.  
  1249. static void
  1250. display_window_size (fancy)
  1251.      int fancy;
  1252. {
  1253.   struct winsize win;
  1254.  
  1255.   if (get_win_size (&win))
  1256.     {
  1257.       if (errno != EINVAL)
  1258.     error (1, errno, "standard input");
  1259.     }
  1260.   else
  1261.     {
  1262.       wrapf (fancy ? "rows %d; columns %d;" : "%d %d\n",
  1263.          win.ws_row, win.ws_col);
  1264.       if (!fancy)
  1265.     current_col = 0;
  1266.     }
  1267. }
  1268. #endif
  1269.  
  1270. static int
  1271. screen_columns ()
  1272. {
  1273. #ifdef TIOCGWINSZ
  1274.   struct winsize win;
  1275.  
  1276.   if (get_win_size (&win))
  1277.     {
  1278.       /* With Solaris 2.[123], this ioctl fails and errno is set to
  1279.      EINVAL for telnet (but not rlogin) sessions.  */
  1280.       if (errno != EINVAL)
  1281.     error (1, errno, "standard input");
  1282.     }
  1283.   else if (win.ws_col > 0)
  1284.     return win.ws_col;
  1285. #endif
  1286.   if (getenv ("COLUMNS"))
  1287.     return atoi (getenv ("COLUMNS"));
  1288.   return 80;
  1289. }
  1290.  
  1291. static tcflag_t *
  1292. mode_type_flag (type, mode)
  1293.      enum mode_type type;
  1294.      struct termios *mode;
  1295. {
  1296.   switch (type)
  1297.     {
  1298.     case control:
  1299.       return &mode->c_cflag;
  1300.  
  1301.     case input:
  1302.       return &mode->c_iflag;
  1303.  
  1304.     case output:
  1305.       return &mode->c_oflag;
  1306.  
  1307.     case local:
  1308.       return &mode->c_lflag;
  1309.  
  1310.     case combination:
  1311.       return NULL;
  1312.  
  1313.     default:
  1314.       abort ();
  1315.     }
  1316. }
  1317.  
  1318. static void
  1319. display_settings (output_type, mode)
  1320.      enum output_type output_type;
  1321.      struct termios *mode;
  1322. {
  1323.   switch (output_type)
  1324.     {
  1325.     case changed:
  1326.       display_changed (mode);
  1327.       break;
  1328.  
  1329.     case all:
  1330.       display_all (mode);
  1331.       break;
  1332.  
  1333.     case recoverable:
  1334.       display_recoverable (mode);
  1335.       break;
  1336.     }
  1337. }
  1338.  
  1339. static void
  1340. display_changed (mode)
  1341.      struct termios *mode;
  1342. {
  1343.   int i;
  1344.   int empty_line;
  1345.   tcflag_t *bitsp;
  1346.   unsigned long mask;
  1347.   enum mode_type prev_type = control;
  1348.  
  1349.   display_speed (mode, 1);
  1350. #ifdef HAVE_C_LINE
  1351.   wrapf ("line = %d;", mode->c_line);
  1352. #endif
  1353.   putchar ('\n');
  1354.   current_col = 0;
  1355.  
  1356.   empty_line = 1;
  1357.   for (i = 0; strcmp (control_info[i].name, "min"); ++i)
  1358.     {
  1359.       if (mode->c_cc[control_info[i].offset] == control_info[i].saneval)
  1360.     continue;
  1361.       empty_line = 0;
  1362.       wrapf ("%s = %s;", control_info[i].name,
  1363.          visible (mode->c_cc[control_info[i].offset]));
  1364.     }
  1365.   if ((mode->c_lflag & ICANON) == 0)
  1366.     {
  1367.       wrapf ("min = %d; time = %d;\n", (int) mode->c_cc[VMIN],
  1368.          (int) mode->c_cc[VTIME]);
  1369.     }
  1370.   else if (empty_line == 0)
  1371.     putchar ('\n');
  1372.   current_col = 0;
  1373.  
  1374.   empty_line = 1;
  1375.   for (i = 0; mode_info[i].name != NULL; ++i)
  1376.     {
  1377.       if (mode_info[i].flags & OMIT)
  1378.     continue;
  1379.       if (mode_info[i].type != prev_type)
  1380.     {
  1381.       if (empty_line == 0)
  1382.         {
  1383.           putchar ('\n');
  1384.           current_col = 0;
  1385.           empty_line = 1;
  1386.         }
  1387.       prev_type = mode_info[i].type;
  1388.     }
  1389.  
  1390.       bitsp = mode_type_flag (mode_info[i].type, mode);
  1391.       mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
  1392.       if ((*bitsp & mask) == mode_info[i].bits)
  1393.     {
  1394.       if (mode_info[i].flags & SANE_UNSET)
  1395.         {
  1396.           wrapf ("%s", mode_info[i].name);
  1397.           empty_line = 0;
  1398.         }
  1399.     }
  1400.       else if ((mode_info[i].flags & (SANE_SET | REV)) == (SANE_SET | REV))
  1401.     {
  1402.       wrapf ("-%s", mode_info[i].name);
  1403.       empty_line = 0;
  1404.     }
  1405.     }
  1406.   if (empty_line == 0)
  1407.     putchar ('\n');
  1408.   current_col = 0;
  1409. }
  1410.  
  1411. static void
  1412. display_all (mode)
  1413.      struct termios *mode;
  1414. {
  1415.   int i;
  1416.   tcflag_t *bitsp;
  1417.   unsigned long mask;
  1418.   enum mode_type prev_type = control;
  1419.  
  1420.   display_speed (mode, 1);
  1421. #ifdef TIOCGWINSZ
  1422.   display_window_size (1);
  1423. #endif
  1424. #ifdef HAVE_C_LINE
  1425.   wrapf ("line = %d;", mode->c_line);
  1426. #endif
  1427.   putchar ('\n');
  1428.   current_col = 0;
  1429.  
  1430.   for (i = 0; strcmp (control_info[i].name, "min"); ++i)
  1431.     {
  1432.       wrapf ("%s = %s;", control_info[i].name,
  1433.          visible (mode->c_cc[control_info[i].offset]));
  1434.     }
  1435.   wrapf ("min = %d; time = %d;\n", mode->c_cc[VMIN], mode->c_cc[VTIME]);
  1436.   current_col = 0;
  1437.  
  1438.   for (i = 0; mode_info[i].name != NULL; ++i)
  1439.     {
  1440.       if (mode_info[i].flags & OMIT)
  1441.     continue;
  1442.       if (mode_info[i].type != prev_type)
  1443.     {
  1444.       putchar ('\n');
  1445.       current_col = 0;
  1446.       prev_type = mode_info[i].type;
  1447.     }
  1448.  
  1449.       bitsp = mode_type_flag (mode_info[i].type, mode);
  1450.       mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
  1451.       if ((*bitsp & mask) == mode_info[i].bits)
  1452.     wrapf ("%s", mode_info[i].name);
  1453.       else if (mode_info[i].flags & REV)
  1454.     wrapf ("-%s", mode_info[i].name);
  1455.     }
  1456.   putchar ('\n');
  1457.   current_col = 0;
  1458. }
  1459.  
  1460. static void
  1461. display_speed (mode, fancy)
  1462.      struct termios *mode;
  1463.      int fancy;
  1464. {
  1465.   if (cfgetispeed (mode) == 0 || cfgetispeed (mode) == cfgetospeed (mode))
  1466.     wrapf (fancy ? "speed %lu baud;" : "%lu\n",
  1467.        baud_to_value (cfgetospeed (mode)));
  1468.   else
  1469.     wrapf (fancy ? "ispeed %lu baud; ospeed %lu baud;" : "%lu %lu\n",
  1470.        baud_to_value (cfgetispeed (mode)),
  1471.        baud_to_value (cfgetospeed (mode)));
  1472.   if (!fancy)
  1473.     current_col = 0;
  1474. }
  1475.  
  1476. static void
  1477. display_recoverable (mode)
  1478.      struct termios *mode;
  1479. {
  1480.   int i;
  1481.  
  1482.   printf ("%lx:%lx:%lx:%lx",
  1483.       (unsigned long) mode->c_iflag, (unsigned long) mode->c_oflag,
  1484.       (unsigned long) mode->c_cflag, (unsigned long) mode->c_lflag);
  1485.   for (i = 0; i < NCCS; ++i)
  1486.     printf (":%x", (unsigned int) mode->c_cc[i]);
  1487.   putchar ('\n');
  1488. }
  1489.  
  1490. static int
  1491. recover_mode (arg, mode)
  1492.      char *arg;
  1493.      struct termios *mode;
  1494. {
  1495.   int i, n;
  1496.   unsigned int chr;
  1497.   unsigned long iflag, oflag, cflag, lflag;
  1498.  
  1499.   /* Scan into temporaries since it is too much trouble to figure out
  1500.      the right format for `tcflag_t'.  */
  1501.   if (sscanf (arg, "%lx:%lx:%lx:%lx%n",
  1502.           &iflag, &oflag, &cflag, &lflag, &n) != 4)
  1503.     return 0;
  1504.   mode->c_iflag = iflag;
  1505.   mode->c_oflag = oflag;
  1506.   mode->c_cflag = cflag;
  1507.   mode->c_lflag = lflag;
  1508.   arg += n;
  1509.   for (i = 0; i < NCCS; ++i)
  1510.     {
  1511.       if (sscanf (arg, ":%x%n", &chr, &n) != 1)
  1512.     return 0;
  1513.       mode->c_cc[i] = chr;
  1514.       arg += n;
  1515.     }
  1516.   return 1;
  1517. }
  1518.  
  1519. struct speed_map
  1520. {
  1521.   const char *string;        /* ASCII representation. */
  1522.   speed_t speed;        /* Internal form. */
  1523.   unsigned long value;        /* Numeric value. */
  1524. };
  1525.  
  1526. struct speed_map speeds[] =
  1527. {
  1528.   {"0", B0, 0},
  1529.   {"50", B50, 50},
  1530.   {"75", B75, 75},
  1531.   {"110", B110, 110},
  1532.   {"134", B134, 134},
  1533.   {"134.5", B134, 134},
  1534.   {"150", B150, 150},
  1535.   {"200", B200, 200},
  1536.   {"300", B300, 300},
  1537.   {"600", B600, 600},
  1538.   {"1200", B1200, 1200},
  1539.   {"1800", B1800, 1800},
  1540.   {"2400", B2400, 2400},
  1541.   {"4800", B4800, 4800},
  1542.   {"9600", B9600, 9600},
  1543.   {"19200", B19200, 19200},
  1544.   {"38400", B38400, 38400},
  1545.   {"exta", B19200, 19200},
  1546.   {"extb", B38400, 38400},
  1547. #ifdef B57600
  1548.   {"57600", B57600, 57600},
  1549. #endif
  1550. #ifdef B115200
  1551.   {"115200", B115200, 115200},
  1552. #endif
  1553.   {NULL, 0, 0}
  1554. };
  1555.  
  1556. static speed_t
  1557. string_to_baud (arg)
  1558.      char *arg;
  1559. {
  1560.   int i;
  1561.  
  1562.   for (i = 0; speeds[i].string != NULL; ++i)
  1563.     if (!strcmp (arg, speeds[i].string))
  1564.       return speeds[i].speed;
  1565.   return (speed_t) -1;
  1566. }
  1567.  
  1568. static unsigned long
  1569. baud_to_value (speed)
  1570.      speed_t speed;
  1571. {
  1572.   int i;
  1573.  
  1574.   for (i = 0; speeds[i].string != NULL; ++i)
  1575.     if (speed == speeds[i].speed)
  1576.       return speeds[i].value;
  1577.   return 0;
  1578. }
  1579.  
  1580. static void
  1581. sane_mode (mode)
  1582.      struct termios *mode;
  1583. {
  1584.   int i;
  1585.   tcflag_t *bitsp;
  1586.  
  1587.   for (i = 0; control_info[i].name; ++i)
  1588.     {
  1589. #if VMIN == VEOF
  1590.       if (!strcmp (control_info[i].name, "min"))
  1591.     break;
  1592. #endif
  1593.       mode->c_cc[control_info[i].offset] = control_info[i].saneval;
  1594.     }
  1595.  
  1596.   for (i = 0; mode_info[i].name != NULL; ++i)
  1597.     {
  1598.       if (mode_info[i].flags & SANE_SET)
  1599.     {
  1600.       bitsp = mode_type_flag (mode_info[i].type, mode);
  1601.       *bitsp = (*bitsp & ~mode_info[i].mask) | mode_info[i].bits;
  1602.     }
  1603.       else if (mode_info[i].flags & SANE_UNSET)
  1604.     {
  1605.       bitsp = mode_type_flag (mode_info[i].type, mode);
  1606.       *bitsp = *bitsp & ~mode_info[i].mask & ~mode_info[i].bits;
  1607.     }
  1608.     }
  1609. }
  1610.  
  1611. /* Return a string that is the printable representation of character CH.  */
  1612. /* Adapted from `cat' by Torbjorn Granlund.  */
  1613.  
  1614. static const char *
  1615. visible (ch)
  1616.      unsigned char ch;
  1617. {
  1618.   static char buf[10];
  1619.   char *bpout = buf;
  1620.  
  1621.   if (ch == _POSIX_VDISABLE)
  1622.     return "<undef>";
  1623.  
  1624.   if (ch >= 32)
  1625.     {
  1626.       if (ch < 127)
  1627.     *bpout++ = ch;
  1628.       else if (ch == 127)
  1629.     {
  1630.       *bpout++ = '^';
  1631.       *bpout++ = '?';
  1632.     }
  1633.       else
  1634.     {
  1635.       *bpout++ = 'M',
  1636.         *bpout++ = '-';
  1637.       if (ch >= 128 + 32)
  1638.         {
  1639.           if (ch < 128 + 127)
  1640.         *bpout++ = ch - 128;
  1641.           else
  1642.         {
  1643.           *bpout++ = '^';
  1644.           *bpout++ = '?';
  1645.         }
  1646.         }
  1647.       else
  1648.         {
  1649.           *bpout++ = '^';
  1650.           *bpout++ = ch - 128 + 64;
  1651.         }
  1652.     }
  1653.     }
  1654.   else
  1655.     {
  1656.       *bpout++ = '^';
  1657.       *bpout++ = ch + 64;
  1658.     }
  1659.   *bpout = '\0';
  1660.   return (const char *) buf;
  1661. }
  1662.  
  1663. /* Parse string S as an integer, using decimal radix by default,
  1664.    but allowing octal and hex numbers as in C.  */
  1665. /* From `od' by Richard Stallman.  */
  1666.  
  1667. static long
  1668. integer_arg (s)
  1669.      char *s;
  1670. {
  1671.   long value;
  1672.   int radix = 10;
  1673.   char *p = s;
  1674.   int c;
  1675.  
  1676.   if (*p != '0')
  1677.     radix = 10;
  1678.   else if (*++p == 'x')
  1679.     {
  1680.       radix = 16;
  1681.       p++;
  1682.     }
  1683.   else
  1684.     radix = 8;
  1685.  
  1686.   value = 0;
  1687.   while (((c = *p++) >= '0' && c <= '9')
  1688.      || (radix == 16 && (c & ~40) >= 'A' && (c & ~40) <= 'Z'))
  1689.     {
  1690.       value *= radix;
  1691.       if (c >= '0' && c <= '9')
  1692.     value += c - '0';
  1693.       else
  1694.     value += (c & ~40) - 'A';
  1695.     }
  1696.  
  1697.   if (c == 'b')
  1698.     value *= 512;
  1699.   else if (c == 'B')
  1700.     value *= 1024;
  1701.   else
  1702.     p--;
  1703.  
  1704.   if (*p)
  1705.     {
  1706.       error (0, 0, "invalid integer argument `%s'", s);
  1707.       usage (1);
  1708.     }
  1709.   return value;
  1710. }
  1711.